Prompt.setattr flips a synced object's state to DIRTY on any assignment to tracked fields without checking equality, so prompt.name = prompt.name becomes DIRTY and save() (lines 775–788) then calls update(name=self.name), issuing an unnecessary API rename. Can we compare the new value to the current one before flipping the sync state so redundant assignments don't trigger updates?

_{Finding type: Logical Bugs | Severity: 🟠 Medium}

Want Baz to fix this for you? Activate Fixer

In src/galileo/__future__/prompt.py around lines 209-214, the __setattr__ method
unconditionally marks tracked fields DIRTY when synced. Change it to first obtain the
current value via object.__getattribute__(self, attr_name) (or use a unique sentinel
with getattr) and compare it to the new value; only call
self._set_state(SyncState.DIRTY) if the values differ. Ensure this comparison handles
the missing-attribute case safely (treat missing as different) and then delegate to
object.__setattr__ to assign the value.

Commit b1e89cf addressed this comment by checking the current tracked attribute value and only marking the prompt DIRTY if the new value differs, preventing redundant rename updates.

What's wrong: Both _update_from_api_response and update() now manually call object.__setattr__(self, "name", …) to bypass the new dirty-tracking override when syncing the name. The same three-line pattern appears twice (lines 301‑304 and again around 506‑511), so any future tracked field or additional sync flow will need the same boilerplate.
Impact: We risk forgetting to bypass the overridden __setattr__ in new code paths, which would incorrectly mark the prompt as DIRTY and block save()/update() operations or cause redundant API calls.
Ask: Can we extract a helper (e.g., _set_synced_name(self, name: str) or a generic _assign_tracked_attr(attr, value)) and call it from both _update_from_api_response and update() so the bypass logic lives in one place and isn’t duplicated?

_{Finding type: Code Dedup and Conventions | Severity: 🟢 Low}

Want Baz to fix this for you? Activate Fixer

• Analysis: There are only two call sites for object.__setattr__(self, "name", ...). A helper for two occurrences is premature abstraction. The pattern is clear and self-documenting with the inline comment. If more tracked fields are added later, a helper would make sense at that point.
• Recommended action: Leave as-is. Two call sites don't warrant an abstraction.

Got it, I’ll leave this pattern as-is and will remember your preference against premature abstraction here once the PR is merged.

Prompt.save() treats any FAILED_SYNC as a name-only dirty state and unconditionally calls self.update(name=self.name) (e.g. after a failed create_version). This can hide the original failure and leave the prompt incorrectly marked SYNCED even though the failed operation never completed. Can we restrict save() to retry only name-related DIRTY changes or record/distinguish the failure source before invoking self.update(name=...)?

_{Finding type: Logical Bugs | Severity: 🔴 High}

Want Baz to fix this for you? Activate Fixer

In src/galileo/__future__/prompt.py around lines 785 to 788, the save() method currently
treats FAILED_SYNC the same as DIRTY and unconditionally calls update(name=self.name),
which can mask unrelated failures. Change this logic so that only SyncState.DIRTY
triggers the update retry: if self.sync_state == SyncState.DIRTY, validate self.id and
call return self.update(name=self.name); if self.sync_state == SyncState.FAILED_SYNC, do
not call update — instead re-raise or surface the stored error (e.g., raise the saved
error from the failed sync state or raise a ValueError instructing the caller to retry
the original operation), preserving the original failure information and avoiding
marking the prompt as SYNCED incorrectly.

Commit b1e89cf addressed this comment by short-circuiting FAILED_SYNC before any update retry and raising a clear ValueError directing callers to resync or retry, ensuring only genuine DIRTY states call update(name=self.name).

• [Minor]: save() docstring is stale — it doesn't document the DIRTY or FAILED_SYNC behavior.
  • File: src/galileo/__future__/prompt.py (lines 756-779)
  • The docstring says "Behavior depends on the prompt's current state" but only lists LOCAL_ONLY, SYNCED, and DELETED. It should also document DIRTY (delegates to update()) and FAILED_SYNC (raises ValueError).
  • Suggestion: Update the docstring to include:

    - DIRTY: Persists name changes via update()
    - FAILED_SYNC: Raises ValueError (use refresh() to re-sync)
    

• [Nit]: _TRACKED_FIELDS is annotated as a class variable with frozenset[str] but it's accessed via self._TRACKED_FIELDS in __setattr__. This works via Python's descriptor protocol, but using type(self)._TRACKED_FIELDS or Prompt._TRACKED_FIELDS would make the intent clearer and avoid potential shadowing if an instance ever sets _TRACKED_FIELDS as an instance attribute.
  • File: src/galileo/__future__/prompt.py (line 211)

• Is there a plan to apply the same __setattr__ dirty-tracking pattern to other __future__ domain objects (Project, Dataset)? If so, it might be worth extracting the __setattr__ logic into the StateManagementMixin base class at that point. Not needed now, but worth considering for consistency across the package.